Developer CD Series 1994 August: Tool Chest/Dev.CD Aug 94.toast/Tool Chest/Interfaces/MPW Interfaces/RIncludes/SysTypes.r

Text File | 1993-09-17 | 55.7 KB | 1,437 lines | [TEXT/MPS ]

/*
    File:        SysTypes.r

    Copyright:    © 1983-1993 by Apple Computer, Inc.
                All rights reserved.

    Version:    System 7.1 for ETO #11
    Created:    Tuesday, March 30, 1993 18:00

*/


#ifndef __SYSTYPES_R__
#define __SYSTYPES_R__

/*----------------------------pslt • Nubus psuedo-slot mapping constants------------------*/
#define    horizAscending        0            /* horizontal form factor, ascending slot order   */
#define    horizDescending        1            /* horizontal form factor, descending slot order  */
#define    vertAscending        2            /* vertical form factor, ascending slot order     */
#define    vertDescending        3            /* vertical form factor, descending slot order    */


/*----------------------------pslt • Nubus pseudo-slot mapping resource-------------------*/
type 'pslt' {
        integer = $$Countof(pSlotSpec);                            /* # of slots               */
        integer;                                                /* Nubus orientation      */
        longint;                                                /* psltFlags, reserved    */
        wide array pSlotSpec {
                integer;                                        /* Nubus slot #              */
                integer;                                        /* pseudo slot #          */
        };
};


/*-------------------------------------Equates------------------------------------------*/
/*    The following are used to set characters used in INTL resources.
*/
#define    periodSymbol        "."
#define    commaSymbol            ","
#define    semicolonSymbol        ";"
#define    dollarsignSymbol    "$"
#define    slashSymbol            "/"
#define    colonSymbol            ":"

#define Script        smRoman, smJapanese, smTradChinese, smKorean,        \
                    smArabic, smHebrew, smGreek, smCyrillic, smRSymbol,    \
                    smDevanagari, smGurmukhi, smGujarati, smOriya,        \
                    smBengali, smTamil, smTelugu, smKannada,            \
                    smMalayalam, smSinhalese, smBurmese, smKhmer,        \
                    smThai, smLaotian, smGeorgian, smArmenian,            \
                    smSimpChinese, smTibetan, smMongolian, smGeez,        \
                    smSlavic, smVietnamese, smExtArabic, smUninterp        \

#define Language    langEnglish, langFrench, langGerman, langItalian,    \
                    langDutch, langSwedish, langSpanish, langDanish,    \
                    langPortuguese, langNorwegian, langHebrew,            \
                    langJapanese, langArabic, langFinnish, langGreek,    \
                    langIcelandic, langMaltese, langTurkish,            \
                    langCroatian, langTradChinese, langUrdu,            \
                    langHindi, langThai, langKorean, langLithuanian,    \
                    langPolish, langHungarian, langEstonian,            \
                    langLettish, langLappish, langFaeroese,                \
                    langFarsi, langRussian, langSimpChinese,            \
                    langFlemish, langIrish, langAlbanian, langRomanian,    \
                    langCzech, langSlovak, langSlovenian, langYiddish,    \
                    langSerbian, langMacedonian, langBulgarian,            \
                    langUkrainian, langByelorussian, langUzbek,            \
                    langKazakh, langAzerbaijani, langAzerbaijanAr,        \
                    langArmenian, langGeorgian, langMoldavian,            \
                    langKirghiz, langTajiki, langTurkmen,                \
                    langMongolian, langMongolianCyr, langPashto,        \
                    langKurdish, langKashmiri, langSindhi, langTibetan,    \
                    langNepali, langSanskrit, langMarathi, langBengali,    \
                    langAssamese, langGujarati, langPunjabi, langOriya,    \
                    langMalayalam, langKannada, langTamil, langTelugu,    \
                    langSinhalese, langBurmese, langKhmer, langLao,        \
                    langVietnamese, langIndonesian, langTagalog,        \
                    langMalayRoman, langMalayArabic, langAmharic,        \
                    langTigrinya, langGalla, langSomali, langSwahili,    \
                    langRuanda, langRundi, langChewa, langMalagasy,        \
                    langEsperanto, langUnspecified = 32767                \

#define    Region        verUS, verFrance, verBritain, verGermany,            \
                    verItaly, verNetherlands, verBelgiumLux,            \
                    verFrBelgiumLux = 6, verSweden, verSpain,            \
                    verDenmark, verPortugal, verFrCanada, verNorway,    \
                    verIsrael, verJapan, verAustralia, verArabia,        \
                    verArabic=16, verFinland, verFrSwiss, verGrSwiss,    \
                    verGreece, verIceland, verMalta, verCyprus,            \
                    verTurkey, verYugoslavia, verYugoCroatian = 25,        \
                    verIndia = 33, verIndiaHindi = 33, verPakistan,        \
                    verLithuania = 41, verPoland, verHungary,            \
                    verEstonia, verLatvia, verLapland, verFaeroeIsl,    \
                    verIran, verRussia, verIreland = 50, verKorea,        \
                    verChina, verTaiwan, verThailand                    \


/*        The following are used to set styles, simply add for desired style.
*/
#define    bold            1
#define italic            2
#define underline        4
#define outline         8
#define shadow            16
#define condense        32
#define extend            64

/*----------------------------DRVR • Driver---------------------------------------------*/
type 'DRVR' {
        boolean = 0;
        boolean            dontNeedLock, needLock;                    /* lock drvr in memory    */
        boolean            dontNeedTime, needTime;                    /* for periodic    action    */
        boolean            dontNeedGoodbye, needGoodbye;            /* call before heap reinit*/
        boolean            noStatusEnable, statusEnable;            /* responds to status    */
        boolean            noCtlEnable, ctlEnable;                    /* responds to control    */
        boolean            noWriteEnable, writeEnable;                /* responds to write    */
        boolean            noReadEnable, readEnable;                /* responds to read        */
        byte = 0;
        integer;                                                /* driver delay            */
        unsigned hex integer;                                    /* desk acc event mask    */
        integer;                                                /* driver menu            */
        unsigned hex integer;                                    /* offset to open        */
        unsigned hex integer;                                    /* offset to prime        */
        unsigned hex integer;                                    /* offset to control    */
        unsigned hex integer;                                    /* offset to status        */
        unsigned hex integer;                                    /* offset to close        */
        pstring;                                                /* driver name            */
        hex string;                                                /* driver code            */
};
/*----------------------------finf • Font Family Description----------------------------*/
type 'finf' {
        integer = $$CountOf(Fonts);                                /* # of fonts            */
        array Fonts {
            integer;                                            /* Font Number            */
            unsigned hex integer    plain;                        /*         Font Style        */
            integer;                                            /*         Font Size        */
        };
};
/*----------------------------FOND • Font Family Description----------------------------*/
/* Note: this FOND resource definition only works when the tables at the end of the
         resource are in this order:    1 - Family Character-Width Table
                                         2 - Style Mapping Table
                                        3 - Kerning Tables
*/
type 'FOND' {
        /* Flags Word */
        boolean        proportionalFont, fixedWidthFont;
        boolean        useFractWidthTable, dontUseFractWidthTable;
        boolean        computeFixedPointExtra, useIntegerExtra;
        boolean        useFractEnable, ignoreFractEnable;
        boolean        canAdjustCharSpacing, dontAdjustCharSpacing;
        unsigned hex bitstring[9] = 0;                            /* Reserved                */
        boolean        noCharWidthTable, hasCharWidthTable;
        boolean        noImageHeightTable, hasImageHeightTable;

        integer;                                                /* Family ID number        */
    First:
        integer;                                                /* first char            */
    Last:
        integer;                                                /* last char            */
        integer;                                                /* Ascent                */
        integer;                                                /* Descent                */
        integer;                                                /* Leading                */
        integer;                                                /* Width Max            */
    WidthOffset:
        unsigned hex longint = WidthTable[1] >> 3;                /* Width table offset    */
    KerningOffset:
        unsigned hex longint = KerningTable[1] >> 3;            /* Kerning table offset    */
    StyleMapOffset:
        unsigned hex longint = StyleTable[1] >> 3;                /* Style map offset        */
        integer;                                                /* reserved                */
        integer;                                                /* ex wid bold            */
        integer;                                                /* ex wid italic        */
        integer;                                                /* ex wid underline        */
        integer;                                                /* ex wid outline        */
        integer;                                                /* ex wid shadow        */
        integer;                                                /* ex wid condensed        */
        integer;                                                /* ex wid extended        */
        integer;                                                /* reserved                */
        longint;                                                /* reserved for intl    */
    Version:
        integer;                                                /* version                */

        /* Font Association Table */
        integer = $$CountOf(FontEntries)-1;                     /* # of font entries    */
        wide array FontEntries {
            integer;                                            /* Font size            */
            unsigned hex integer    plain;                        /*         Font Style        */
            integer;                                            /* Resource ID of FONT    */
        };
        /*  */
        array [$$Word(Version) == 2] {
    OffsetTableStart:
            integer = $$CountOf(OffsetTable) - 1;
            array OffsetTable {
                longint = (BBoxStart[1] - OffsetTableStart[1]) >> 3;
            };
            /* Font Bounding Box Table */
    BBoxStart:
            integer = $$CountOf(BBoxTable) - 1;
            wide array BBoxTable {
                fill bit[9];                                    /* Reserved                */
                Boolean        noExtendedStyle, EXTENDEDstyle;        /* Extended style        */
                Boolean        noCondensedStyle, CONDENSEDstyle;    /* Condensed style        */
                Boolean        noShadowStyle, SHADOWstyle;            /* Shadow style            */
                Boolean        noOutlineStyle, OUTLINEstyle;        /* Outline style        */
                Boolean        noUnderline, UNDERLINEstyle;        /* Underline style        */
                Boolean        noItalicStyle, ITALICstyle;            /* Italic style            */
                Boolean        noBoldStyle, BOLDstyle;                /* Bold style            */
                Rect;
            };
        };

        /* Family Character-Width Table */
        /* This outer array below handles the case when the width table offset (WidthOffset:)
           is zero. */
        array [$$Long(WidthOffset) != 0] {
    WidthTable:
            integer = $$CountOf(WidthTable) - 1;                /* # of width tables    */
            wide array WidthTable {
                fill bit[9];                                    /* Reserved                */
                Boolean        noExtendedStyle, EXTENDEDstyle;        /* Extended style        */
                Boolean        noCondensedStyle, CONDENSEDstyle;    /* Condensed style        */
                Boolean        noShadowStyle, SHADOWstyle;            /* Shadow style            */
                Boolean        noOutlineStyle, OUTLINEstyle;        /* Outline style        */
                Boolean        noUnderline, UNDERLINEstyle;        /* Underline style        */
                Boolean        noItalicStyle, ITALICstyle;            /* Italic style            */
                Boolean        noBoldStyle, BOLDstyle;                /* Bold style            */

                wide array [$$Word(Last) - $$Word(First) + 3] {
                    unsigned hex integer;                        /* Width of character    */
                };
            };
        };

        /* Style Mapping Table */
        /* This outer array below handles the case when the width table offset (WidthOffset:)
           is zero. */
        array [$$Long(StyleMapOffset) != 0] {
    StyleTable:
            unsigned hex integer;                                /* Font class            */
    CharCodeOffset:
            unsigned hex longint =                                /* Encoding table offset*/
                (CharCodeTable[1,1] - StyleTable[1]) / 8 * (CharCodeTable[1,1] != 0);
            fill long;                                            /* Reserved                */
            array [48] {
                byte;
            };
            /* Style Name Table */
            integer = $$CountOf(StyleNames);                    /* Number of strings    */
            pstring;                                            /* Full base font name    */
            array StyleNames {
                pstring;                                        /* Style suffix names    */
            };

            /* Character Set Encoding Table */
            /* This outer array below handles the case when the character set encoding
               offset is zero (CharCodeOffset:) */
            array [$$Long(CharCodeOffset[1]) != 0] {
    CharCodeTable:
                integer = $$CountOf(CharacterCodes);            /* Number of entries    */
                wide array CharacterCodes {
                    char;                                        /* Character code        */
                    pstring;                                    /* Char name string        */
                };
            };
        };

        /* Kerning Tables */
        /* This outer array below handles the case when the kerning table offset
           (KerningOffset:) is zero. */
        array [$$Long(KerningOffset) != 0] {
            /* Kerning Tables */
    KerningTable:
            integer = $$CountOf(KerningTables) - 1;                /* Number of tables        */
            wide array KerningTables {
                fill bit[9];                                    /* Reserved                */
                Boolean        noExtendedStyle, EXTENDEDstyle;        /* Extended style        */
                Boolean        noCondensedStyle, CONDENSEDstyle;    /* Condensed style        */
                Boolean        noShadowStyle, SHADOWstyle;            /* Shadow style            */
                Boolean        noOutlineStyle, OUTLINEstyle;        /* Outline style        */
                Boolean        noUnderline, UNDERLINEstyle;        /* Underline style        */
                Boolean        noItalicStyle, ITALICstyle;            /* Italic style            */
                Boolean        noBoldStyle, BOLDstyle;                /* Bold style            */
                integer = $$CountOf(KerningTableEntry);            /* # of entries            */
                wide array KerningTableEntry {
                    char;                                        /* first char of pair    */
                    char;                                        /* second char of pair    */
                    unsigned hex integer;                        /* kerning offset        */
                };
            };
        };
};
/*----------------------------FONT • Font Description-----------------------------------*/
/* PROBLEMS: the offset to the offset/width table has been changed to a longint, with the
             high word stored in the neg descent field (if its not -1).  Rez can't handle
             this. */
type 'FONT' {
        /* Font Type Flags */
FontType:
        boolean = 1;                                            /* Reserved                */
        boolean        doExpandFont, dontExpandFont;
        boolean        proportionalFont, fixedWidthFont;
        boolean = 1;                                            /* Reserved                */
        unsigned bitstring[2] = 0;                                /* Reserved                */
        boolean        blackFont, colorFont;
        boolean        notSynthetic, isSynthetic;
        boolean        nofctbRsrc, hasfctbRsrc;
        unsigned bitstring[3] = 0;                                /* Reserved                */
        unsigned bitstring[2]    oneBit, twoBit,                    /* Font depth            */
                                fourBit, eightBit;
        boolean        noCharWidthTable, hasCharWidthTable;
        boolean        noImageHeightTable, hasImageHeightTable;

    FirstChar:
        integer;                                                /* first char            */
    LastChar:
        integer;                                                /* last char            */
        integer;                                                /* width max            */
        integer;                                                /* kern max                */
        integer;                                                /* neg descent            */
        integer;                                                /* font rect width        */
    Height:
        integer;                                                /* font rect height        */
    Offset:
        unsigned integer = ((WidthTable-Offset)/16);            /* offset to off/wid tab*/
        integer;                                                /* ascent                */
        integer;                                                /* descent                */
        integer;                                                /* leading                */
    RowWords:
        integer;                                                /* row width (in words)    */

        /* Tables */
        /* Bit image */
        hex string [($$Word(RowWords) <<($$BitField(FontType, 12, 2)
            & 3) + 1) * $$Word(Height)];

        /* Location Table */
        array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
            integer;
        };

        /* Offset/Width Table */
    WidthTable:
        array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
            integer;
        };

        /* Optional Character Width Table */
        Array [($$Word(FontType) & 0x0002) != 0] {
            array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
                integer;
            };
        };

        /* Optional Image Height Table */
        Array [($$Word(FontType) & 0x0001) != 0] {
            array [$$Word(LastChar) - $$Word(FirstChar) + 3] {
                integer;
            };
        };
};
/*----------------------------FWID • Font Width Table-----------------------------------*/
type 'FWID' {
        unsigned hex integer;                                    /* Font type            */
        integer;                                                /* first char            */
        integer;                                                /* last char            */
        integer;                                                /* width max            */
        integer;                                                /* kern max                */
        integer;                                                /* neg descent            */
        integer;                                                /* font rect width        */
        integer;                                                /* font rect height        */
        unsigned hex integer;                                    /* offset to off/wid tab*/
        integer;                                                /* ascent                */
        integer;                                                /* descent                */
        integer;                                                /* leading                */
        integer;                                                /* row width (in words)    */
        wide array {                                            /* offset/width table    */
            byte;                                                /* char offset            */
            byte;                                                /* char width            */
        };
};
/*----------------------------gmcd • Guard Mechanism for Compression/Decompression------*/
type 'gmcd' {
        integer = $$Countof(TypeIDArray);
        array TypeIDArray {
            literal longint;                                    /* resource type */
            integer;                                            /* resource ID */
        };
};
/*----------------------------insc • Installer Script-----------------------------------*/
#define    CommFlags                                                                            \
        boolean        noDelRemove, delRemove;                /* Remove file if remove clicked*/ \
        boolean        noDelInstall, delInstall;            /* Delete target before copy    */ \
        boolean        noCopy, copy;                        /* Copy file to destination        */ \
        fill bit[3];                                    /* Reserved                        */ \
        boolean        doReplace, dontReplace;                /* Replace                        */ \
        fill bit[1];                                    /* Reserved                        */ \
        boolean        old, noOld;                            /* Type & creator need not match*/ \
        boolean        noUpdateOnly, updateOnly            /* Only update if target exists    */

#define    FileSpecFlags                                                                       \
        CommFlags;                                                                           \
        boolean        noRsrcFork, rsrcFork;                /* Apply operation to rsrc fork */ \
        boolean        noDataFork, dataFork;                /* Apply operation to data fork    */ \
        boolean        needExist, needNotExist;            /* File need not exist            */ \
        boolean        noCrDate, crDate;                    /* Creation date must match        */ \
        boolean        noTypeCr, typeCr;                    /* Type and creator must match    */ \
        bitstring[1] = 1                                /* Indicates file specification    */

#define    RsrcSpecFlags                                                                       \
        CommFlags;                                                                           \
        fill bit;                                        /* Reserved                        */ \
        boolean        noEvenIf, evenIf;                    /* Do it even if rsrc protected */ \
        boolean        needExist, needNotExist;            /* Rsrc need not exist            */ \
        fill bit;                                        /* Reserved                        */ \
        boolean noByID, byID;                            /* Use name or id to find rsrc    */ \
        bitstring[1] = 0                                /* Indicates rsrc specification    */

#define    FileSpec                                                                           \
        FileSpecFlags;                                    /* FileSpec Flags                */ \
        literal longint;                                /* File Type                    */ \
        literal longint;                                /* File Creator                    */ \
        unsigned hex longint;                            /* Creation Date, use               \
                                                           $$DateToLongInt() to read in       \
                                                           the date.                    */ \
        fill long[3];                                    /* Handle, FDelSize, FAddSize    */ \
        pstring;                                        /* File Name                    */ \
        align word

type 'insc' {
        switch {
            case format0:
                key integer = 0;                                /* Script Format        */
                hex integer = 0;                                /* Script Flags            */
                pstring;                                        /* Script Name            */
                align word;
                wstring;                                        /* Script Help            */
                align word;
                unsigned integer = $$CountOf(FileList);            /* File List            */
                wide array FileList {
                    FileSpec;                                    /* File Spec            */
                };
                unsigned integer = $$CountOf(ResFileList);        /* Resource File List    */
                wide array ResFileList {
                    FileSpec;                                    /* Target File Spec        */
                    integer = $$CountOf(SrcFileList);            /* Source File List        */
                    wide array SrcFileList {
                        FileSpec;                                /* Source File Spec        */
                        unsigned integer = $$CountOf(ResList);    /* Resource List        */
                        wide array ResList {
                            RsrcSpecFlags;                        /* Resource Spec Flags    */
                            literal longint;                    /* Resource Type        */
                            integer;                            /* Source ID            */
                            integer;                            /* Target ID            */
                            fill word[2];                        /* CRC/Version, Filler1    */
                            fill long[3];                        /* Filler2, RDelSize,
                                                                    RAddSize            */
                            pstring;                            /* Resource Name        */
                            align word;
                            integer = 0;                        /* Previous CRC List    */
                        };
                    };
                };
                integer = 0;                                    /* Disk Blocks            */

            case format1:
                key integer = 1;                                /* Script Format        */
                hex integer = 0;                                /* Script Flags            */
                pstring;                                        /* Script Name            */
                align word;
                wstring;                                        /* Script Help            */
                align word;
                unsigned integer = $$CountOf(FileList);            /* File List            */
                wide array FileList {
                    FileSpec;                                    /* File Spec            */
                };
                unsigned integer = $$CountOf(ResFileList);        /* Resource File List    */
                wide array ResFileList {
                    FileSpec;                                    /* Target File Spec        */
                    integer = $$CountOf(SrcFileList);            /* Source File List        */
                    wide array SrcFileList {
                        FileSpec;                                /* Source File Spec        */
                        unsigned integer = $$CountOf(ResList);    /* Resource List        */
                        wide array ResList {
                            RsrcSpecFlags;                        /* Resource Spec Flags    */
                            literal longint;                    /* Resource Type        */
                            integer;                            /* Source ID            */
                            integer;                            /* Target ID            */
                            fill word[2];                        /* CRC/Version, Filler1    */
                            fill long[3];                        /* Filler2, RDelSize,
                                                                   RAddSize                */
                            pstring;                            /* Resource Name        */
                            align word;
                            integer = 0;                        /* Previous CRC List    */
                        };
                    };
                };
                unsigned integer;                                /* Boot Block Version    */
                unsigned integer;                                /* Number of Open Files    */
                unsigned integer;                                /* Number of Events        */
                unsigned hex longint;                            /* Sys Heap Size 128K    */
                unsigned hex longint;                            /* Sys Heap Size 256K    */
                unsigned hex longint;                            /* Sys Heap Size 512K    */
          };
};
/*----------------------------INTL (0) • International Formatting Information-----------*/
type 'INTL' (0) {
        char        period = periodSymbol;                        /* decimal pt sep        */
        char        comma = commaSymbol;                        /* thousands sep        */
        char        semicolon = semicolonSymbol;                /* list sep                */
        char        dollarsign = dollarsignSymbol;                /* currSym1                */
        char;                                                    /* currSym2                */
        char;                                                    /* currSym3                */

        /* currFmt */
        boolean        noLeadZero, leadingZero;                    /* leading unit zero    */
        boolean        noTrailingZero, trailingZero;                /* trailing dec zero    */
        boolean        paren, minusSign;                            /* negative rep            */
        boolean        trails, leads;                                /* curr sym position    */
        fill bit[4];                                            /* not used                */
        byte        monDayYear, dayMonYear, yearMonDay,            /* dateOrder            */
                    monYearDay, dayYearMon, yearDayMon;

        /* shrtDateFmt */
        boolean        noCentury, century;                            /* century incl            */
        boolean        noMonthLeadZero, monthLeadZero;                /* mon lead zero        */
        boolean        noDayLeadZero, dayLeadZero;                    /* day lead zero        */
        fill bit[5];                                            /* filler                */
        char        slash = slashSymbol;                        /* date sep                */
        byte        twentyFourHour, twelveHourZeroCycle,        /* timeCycle            */
                    twelveHour = 255;

        /* timeFmt */
        boolean        noHoursLeadZero, hoursLeadZero;                /* hours lead zero        */
        boolean        noMinutesLeadZero, minutesLeadZero;            /* min lead zero        */
        boolean        noSecondsLeadZero, secondsLeadZero;            /* sec lead zero        */
        fill bit[5];                                            /* filler                */
        string[4];                                                /* mornStr                */
        string[4];                                                /* eveStr                */
        char;                                                    /* timeSep                */
        char;                                                    /* time1Stuff            */
        char;                                                    /* time2Stuff            */
        char;                                                    /* time3Stuff            */
        char;                                                    /* time4Stuff            */
        char;                                                    /* time5Stuff            */
        char;                                                    /* time6Stuff            */
        char;                                                    /* time7Stuff            */
        char;                                                    /* time8Stuff            */
        byte        standard, metric = 255;                        /* metricSys            */
        byte        Region;                                        /* INTL0 region            */
        byte;                                                    /* version                */
};
/*----------------------------itl0 • International Formatting Information---------------*/
type 'itl0' as 'INTL' (0);
/*----------------------------INTL (1) • International Date/Time Information------------*/
type 'INTL' (1) {
        /* Day names */
        array [7] {
            pstring[15];                                        /* Sunday, Monday...    */
        };

        /* Month names */
        array [12] {
            pstring[15];                                        /* January, February...    */
        };

        byte        dayName, none=255;                            /* suppressDay            */
        byte        dayMonYear, monDayYear = 255;                /* longDate format        */
        byte        noDayLeadZero, dayLeadZero = 255;            /* dayLeading0            */
        byte;                                                    /* abbrLen                */
        string[4];                                                /* st0                    */
        string[4];                                                /* st1                    */
        string[4];                                                /* st2                    */
        string[4];                                                /* st3                    */
        string[4];                                                /* st4                    */
        byte        Region;                                        /* INTL1 region         */
        byte;                                                    /* version                */
        hex string    DefaultReturn = "\$4E\$75";                    /* local routine - If
                                                                     you have one, use
                                                                   $$Resource to insert
                                                                   code here.  Otherwise,
                                                                   you must have a 68000
                                                                   return instruction.
                                                                   Use DefaultReturn.    */
};
/*----------------------------itl1 • International Date/Time Information----------------*/
/* This is separated out because it is changed for 7.0 to be different than 'INTL' (1).    */
/* The old INTL (1) format had a local routine field at the end. This was to be used    */
/* for localized string sorting code. However, for the last 4 years, string sorting has    */
/* been handled with the 'itl2' resource, and the local routine field has been ignored.    */
/* In most 'itl1' resources, it just contains a single RTS instruction (hex $4E75).        */
/* This field is now used to flag the 7.0 extensions. If it is $4E75, the old format is    */
/* assumed. If it is $A89F, the new format is assumed: $A89F is unimplemented trap,        */
/* which would never have occurred as the first instruction in a local routine. Old        */
/* 'itl1' resources with a local routine will be handled correctly by the code, but can    */
/* not be Rezzed or DeRezzed with this template. They should be updated to either have    */
/* $4E75 in the local routine field, with nothing else following, or to have $A89F in    */
/* the local routine filed, followed by extended data in the format given below. The    */
/* version field was not used to mark this change because various current 'itl1'        */
/* resources use very different version numbers, including 0, 1, and 128.                */

type 'itl1' {
        /* Day names */
        array [7] {
            pstring[15];                                        /* Sunday, Monday...    */
        };

        /* Month names */
        array [12] {
            pstring[15];                                        /* January, February...    */
        };

        byte        dayName, none=255;                            /* suppressDay            */
        byte        dayMonYear, monDayYear = 255;                /* longDate format        */
        byte        noDayLeadZero, dayLeadZero = 255;            /* dayLeading0            */
        byte;                                                    /* abbrLen                */
        string[4];                                                /* st0                    */
        string[4];                                                /* st1                    */
        string[4];                                                /* st2                    */
        string[4];                                                /* st3                    */
        string[4];                                                /* st4                    */
        byte        Region;                                        /* region code             */
        byte;                                                    /* version                */
        switch    {
            case oldFormat:
                key hex integer = $4E75;                        /* old format key        */
            case extFormat:
                key hex integer = $A89F;                        /* extended format key    */
                hex integer;                                    /* version                */
                hex integer;                                    /* format                */
                integer;                                        /* calendar code        */
                unsigned longint = extraDays >> 3;                            /* offset to extraDays table    */
                unsigned longint = (endExtraDays - extraDays) >> 3;            /* length of extraDays table    */
                unsigned longint = extraMonths >> 3;                        /* offset to extraMonths table    */
                unsigned longint = (endExtraMonths - extraMonths) >> 3;        /* length of extraMonths table    */
                unsigned longint = abbrevDays >> 3;                            /* offset to abbrevDays table    */
                unsigned longint = (endAbbrevDays - abbrevDays) >> 3;        /* length of abbrevDays table    */
                unsigned longint = abbrevMonths >> 3;                        /* offset to abbrevMonths table    */
                unsigned longint = (endAbbrevMonths - abbrevMonths) >> 3;    /* length of abbrevMonths table    */
                unsigned longint = extraSeparators >> 3;                    /* offset to extraSeparators table    */    /*<10>*/
                unsigned longint = (endExtraSeparators - extraSeparators) >> 3;    /* len of extraSeparators table    */    /*<10>*/
extraDays:
                integer = $$CountOf(extraDaysArray);            /* number of extra days    */
                array extraDaysArray {                            /* array of extra names        */
                    pstring;                                    /* extra day name string    */
                };
                align word;                                                                            /*<22>*/
endExtraDays:
extraMonths:
                integer = $$CountOf(extraMonthArray);            /* number of extra months    */
                array extraMonthArray {                            /* array of extra names        */
                    pstring;                                    /* extra month name string    */
                };
                align word;                                                                            /*<22>*/
endExtraMonths:
abbrevDays:
                integer = $$CountOf(abbrevDaysArray);            /* number of abbrev days    */
                array abbrevDaysArray {                            /* array of abbrev names    */
                    pstring;                                    /* abbrev day name string    */
                };
                align word;                                                                            /*<22>*/
endAbbrevDays:
abbrevMonths:
                integer = $$CountOf(abbrevMonthArray);            /* number of abbrev months    */
                array abbrevMonthArray {                        /* array of abbrev names    */
                    pstring;                                    /* abbrev month name string    */
                };
                align word;                                                                            /*<22>*/
endAbbrevMonths:
extraSeparators:
                integer = $$CountOf(extraSeparatorsArray);        /* number of extra separators    */    /*<10>*/
                array extraSeparatorsArray {                    /* array of separator strings    */    /*<10>*/
                    pstring;                                    /* separator string                */    /*<10>*/
                };
                align word;                                                                            /*<22>*/
endExtraSeparators:
        };
};
/*----------------------------itl2 • International String Comparison Package Hooks-----*/
/*
 * Note that this type assumes a particular ordering of code and tables, although
 * that order is not required in order for the resource to be used correctly by
 * the code.
 *
 * There is some ugly stuff at the end, because
 * 1. The itl2 resource has several different formats.
 * 2. The offset to the FindScriptTable is only present in one format: when length
 *    fields exist.
 * 3. Even in that format, the FindScriptTable itself is optional; if it is not
 *    present, the offset to it is 0.
 * 4. The optional FindScriptTable is preceded by the variable-length wrapTable.
 *    To determine the wrapTable length when DeRezzing, we need to use the offset
 *    to FindScriptTable if the offset exists and is nonzero. Otherwise, wrapTable
 *    extends to the end of the resource.
 * The single hex string at the end of the wrapTable is actually represented in
 * three different arrays whose dimensions are logical expressions. For a given
 * format, one of the arrays will have a dimension 1, and the others will have a
 * dimension 0.
 */

type 'itl2' {
        switch {
            case pre604:
                integer = initHook1 >> 3;                            /* init hook offset            */
                integer = fetchHook1 >> 3;                            /* fetch hook offset        */
                integer = vernierHook1 >> 3;                        /* vernier hook offset        */
                integer = projectHook1 >> 3;                        /* project hook offset        */
                bitstring[15] = rsvd1Hook1 >> 4;
                key boolean = 0;
                integer = rsvd2Hook1 >> 3;                            /* rsvd2 hook offset        */
    initHook1:
                hex string [(fetchHook1 - initHook1) >> 3];            /* initHook code            */
    fetchHook1:
                hex string [(vernierHook1 - fetchHook1) >> 3];        /* fetchHook code            */
    vernierHook1:
                hex string [(projectHook1 - vernierHook1) >> 3];    /* vernierHook code            */
    projectHook1:
                hex string [(rsvd1Hook1 - projectHook1) >> 3];        /* projectHook code            */
    rsvd1Hook1:
                hex string [(rsvd2Hook1 - rsvd1Hook1) >> 3];        /* rsvd1Hook code            */
    rsvd2Hook1:
                hex string;                                            /* rsvd2Hook/exitHook code    */
            case atLeast604:
                integer = initHook2 >> 3;                            /* init hook offset            */
                integer = fetchHook2 >> 3;                            /* fetch hook offset        */
                integer = vernierHook2 >> 3;                        /* vernier hook offset        */
                integer = projectHook2 >> 3;                        /* project hook offset        */
                bitstring[15] = -1;
                key boolean = 1;
                integer = rsvd2Hook2 >> 3;                            /* rsvd2 hook offset        */
                integer = typeList >> 3;                            /* TypeList offset            */
                integer = classArray >> 3;                            /* ClassArray offset        */
                integer = upperList >> 3;                            /* UpperList offset            */
                integer = lowerList >> 3;                            /* LowerList offset            */
                integer = upperNoMarkList >> 3;                        /* UpperNoMarkList offset    */
                integer = wordTable >> 3;                            /* WordTable offset            */
                integer = wrapTable >> 3;                            /* WrapTable offset            */
                integer = noMarkList >> 3;                            /* NoMarkList offset        */
                unsigned hex integer;                                /* version number            */
    formatCode:
                switch {
                    case noLengthFields:
                        key integer = 0;                            /* format code                */
    extraHdr:
                        hex string [(initHook2 - extraHdr) >> 3];    /* extra header, if any        */
                    case haveLengthFields:
                        key integer = 1;                            /* format code                */
                        wide array [14] {
                            integer;                                /* length fields            */
                        };
    findScriptTableOffset:
                        integer = findScriptTable[1,1] >> 3;        /* findScriptTable offset    */
                        integer;                                    /* findScriptTable length    */
                };
    initHook2:
                hex string [(fetchHook2 - initHook2) >> 3];            /* initHook code             */
    fetchHook2:
                hex string [(vernierHook2 - fetchHook2) >> 3];        /* fetchHook code             */
    vernierHook2:
                hex string [(projectHook2 - vernierHook2) >> 3];    /* vernierHook code         */
    projectHook2:
                hex string [(rsvd2Hook2 - projectHook2) >> 3];        /* projectHook code         */
    rsvd2Hook2:
                hex string [(classArray - rsvd2Hook2) >> 3];        /* rsvd2Hook/exitHook code    */                                                    /* code */
    classArray:
                hex string [(typeList - classArray) >> 3];            /* classArray table            */
    typeList:
                hex string [(upperList - typeList) >> 3];            /* typeList table            */
    upperList:
                hex string [(lowerList - upperList) >> 3];            /* upperList table            */
    lowerList:
                hex string [(upperNoMarkList - lowerList) >> 3];    /* lowerList table            */
    upperNoMarkList:
                hex string [(noMarkList - upperNoMarkList) >> 3];    /* upperNoMarkList table    */
    noMarkList:
                hex string [(wordTable - noMarkList) >> 3];            /* noMarkList table            */
    wordTable:
                switch {
                    case tupleFormat:
                        key boolean = 0;
                        hex bitstring[7];                            /* class for null            */
                        hex string [255];                            /* class for other chars    */
                        integer = $$CountOf(WordTuples) - 1;
                        wide array WordTuples {                        /* packed tuple defns        */
                            hex unsigned integer;
                        };
                    case stateFormat:
                        key boolean = 1;
                        bitstring[15];                                /* flags & format            */
                        unsigned hex integer;                        /* version                    */
                        integer = (wordClass - wordTable) >> 3;        /* offset to class table    */
                        integer = (wordAux - wordTable) >> 3;        /* offset to aux class tbl    */
                        integer = (wordBackwd - wordTable) >> 3;    /* offset to back state tbl    */
                        integer = (wordForwd - wordTable) >> 3;        /* offset to forw state tbl    */
                        integer;                                    /* doBackupMin                */
    wordLength:
                        integer;                                    /* length                    */
    wordClass:
                        hex string [(wordAux - wordClass) >> 3];    /* class table                */
    wordAux:
                        hex string [(wordBackwd - wordAux) >> 3];    /* aux class table            */
    wordBackwd:
                        hex string [(wordForwd - wordBackwd) >> 3];    /* state table for backup    */
    wordForwd:
                        hex string [$$Word(wordLength) - ((wordForwd - wordTable) >> 3)]; /* tbl */
                };
    endWordTable:
                hex string [(wrapTable - endWordTable) >> 3];        /* extra stuff, if any        */
    wrapTable:
                switch {
                    case tupleFormat:
                        key boolean = 0;
                        hex bitstring[7];                            /* class for null            */
                        hex string [255];                            /* class for other chars    */
                        integer = $$CountOf(WrapTuples) - 1;
                        wide array WrapTuples {                        /* packed tuple defns        */
                            hex unsigned integer;
                        };
                    case stateFormat:
                        key boolean = 1;
                        bitstring[15];                                /* flags & format            */
                        unsigned hex integer;                        /* version                    */
                        integer = (wrapClass - wrapTable) >> 3;        /* offset to class table    */
                        integer = (wrapAux - wrapTable) >> 3;        /* offset to aux class tbl    */
                        integer = (wrapBackwd - wrapTable) >> 3;    /* offset to back state tbl    */
                        integer = (wrapForwd - wrapTable) >> 3;        /* offset to forw state tbl    */
                        integer;                                    /* doBackupMin                */
    wrapLength:
                        integer;                                    /* length                    */
    wrapClass:
                        hex string [(wrapAux - wrapClass) >> 3];    /* class table                */
    wrapAux:
                        hex string [(wrapBackwd - wrapAux) >> 3];    /* aux class table            */
    wrapBackwd:
                        hex string [(wrapForwd - wrapBackwd) >> 3];    /* state table for backup    */
    wrapForwd:
                        hex string [$$Word(wrapLength) - ((wrapForwd - wrapTable) >> 3)]; /* tbl */
                };
    endWrapTable:
                array [$$Word(formatCode) == 0] {
                    hex string;                                        /* extra stuff, if any        */
                };
                array [$$Word(formatCode) == 1] {
                    array [$$Word(findScriptTableOffset) == 0] {
                        hex string;                                    /* extra stuff, if any        */
                    };
                    array [$$Word(findScriptTableOffset) != 0] {
                        hex string [(findScriptTable[1,1] - endWrapTable) >> 3]; /* xtra stuff?    */
                    };
                };
                array [$$Word(formatCode) == 1] {
                    array [$$Word(findScriptTableOffset) != 0] {
    findScriptTable:
                        hex string;                                    /* findScriptTable            */
                    };
                };
        };
};
/*----------------------------itl4 • International Tokenizer----------------------------*/
type 'itl4' {
        unsigned hex integer;                                        /* flags                    */
        literal longint = 'itl4';                                    /* resource type            */
        integer;                                                    /* resource ID                */
        unsigned hex integer;                                        /* version number            */
    formatCode:
        switch {
            case noLengthFields:
                key integer = 0;                                    /* format code                */
                integer = 0;                                        /* reserved                    */
                longint = 0;                                        /* reserved                    */
                integer = 8;                                        /* # of table entries        */
                unsigned longint = mapCharTable >> 3;                /* MapChar offset            */
                unsigned longint = stringCopyCode >> 3;                /* stringCopy offset        */
                unsigned longint = extendFetchCode >> 3;            /* extendFetch offset        */
                unsigned longint = unTokenTable >> 3;                /* unToken offset            */
                unsigned longint = defaultPartsTable >> 3;            /* defaultParts offset        */
                unsigned longint = whiteSpaceList[1] >> 3;            /* whiteSpaceList offset    */
                unsigned longint = 0;                                /* reserved offset            */
                unsigned longint = 0;                                /* reserved offset            */
            case haveLengthFields:
                key integer = 1;                                    /* format code                */
                integer = 0;                                        /* reserved                    */
                longint = 0;                                        /* reserved                    */
                integer = 8;                                        /* # of table entries        */
                unsigned longint = mapCharTable >> 3;                /* MapChar offset            */
                unsigned longint = stringCopyCode >> 3;                /* stringCopy offset        */
                unsigned longint = extendFetchCode >> 3;            /* extendFetch offset        */
                unsigned longint = unTokenTable >> 3;                /* unToken offset            */
                unsigned longint = defaultPartsTable >> 3;            /* defaultPartsTable offset    */
                unsigned longint = whiteSpaceList[1] >> 3;            /* whiteSpaceList offset    */
                unsigned longint = 0;                                /* reserved offset            */
                unsigned longint = 0;                                /* reserved offset            */
                integer;                                            /* MapChar length            */
                integer;                                            /* StringCopy length        */
                integer;                                            /* extendFetch length        */
                integer;                                            /* unToken length            */
                integer;                                            /* defaultPartsTable length    */
                integer;                                            /* whiteSpaceList length    */
                integer = 0;                                        /* reserved length            */
                integer = 0;                                        /* reserved length            */
        };


        unsigned longint;                                            /* extendFetch abort offset    */
        longint = $$CountOf(MapChar);
    mapCharTable:
        array MapChar {
            byte;
        };

    extendFetchCode:
        hex string [(stringCopyCode - extendFetchCode) >> 3];        /* extendFetch code            */
    stringCopyCode:
        hex string [(unTokenTable - stringCopyCode) >> 3];            /* stringCopy code            */
    unTokenTable:
        integer = (defaultPartsTable - unTokenTable) >> 3;            /* unToken table size        */
    unTokenCount:
        integer = $$CountOf(unTokenStringOffsets) - 1;
        array unTokenStringOffsets {
            integer;                                                /* offset to token strings    */
        };
        array [$$Word(unTokenCount) + 1] {
            pstring;                                                /* token strings            */
            align word;
        };

    defaultPartsTable:
        integer;                                                    /* version number            */
        wide array [31] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                        */
        wide array [10] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                        */
        wide array [10] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                        */
        wide array [10] {
            unsigned byte;
            char;
        };
        integer;                                                    /* size                        */
        wide array [10] {
            unsigned byte;
            char;
        };
        hex string [20] = "";

        array [$$BitField(formatCode,30*8,32) != 0] {
    whiteSpaceList:
            integer = (whiteSpaceListEnd[1] - whiteSpaceList[1]) >> 3; /* whiteSpaceList size    */
    whiteSpaceListCount:
            integer = $$CountOf(whiteSpaceStringOffsets);
            array whiteSpaceStringOffsets {
                integer;                                            /* offset to string            */
            };
            array [$$Word(whiteSpaceListCount[1])] {
                pstring;                                            /* whitespace string        */
                align word;
            };
    whiteSpaceListEnd:
        };
};
/*----------------------------itlb • International Script Bundle------------------------*/
type 'itlb' {
        integer;                                                /* itl0 id number        */                /*<6>*/
        integer;                                                /* itl1 id number        */                /*<6>*/
        integer;                                                /* itl2 id number        */                /*<6>*/
        unsigned hex integer;                                    /* script flags - see
                                                                   smScriptFlags info
                                                                   in ScriptEqu.a        */
        integer;                                                /* itl4 id number        */                /*<6>*/
        integer;                                                /* id number of optional itl5, or 0    */    /*<13>*/
        unsigned integer;                                        /* Script language        */
        unsigned integer;                                        /* high byte - number
                                                                   representation code,
                                                                   low byte - date
                                                                   representation code    */
        integer;                                                /* KCHR id number        */                /*<6>*/
        integer;                                                /* id no. of SICN or kcs#,kcs4,kcs8    */    /*<6>*/
        unsigned longint;                                        /* size of script's local record    */    /*<6>*/
        integer;                                                /* default monospace FOND ID        */    /*<6>*/
        unsigned integer;                                        /* default monospace font size        */    /*<6>*/
        integer;                                                /* preferred FOND ID                */    /*<6>*/
        unsigned integer;                                        /* preferred font size                */    /*<6>*/
        integer;                                                /* default small FOND ID            */    /*<6>*/
        unsigned integer;                                        /* default small font size            */    /*<6>*/
        integer;                                                /* default system FOND ID            */    /*<6>*/
        unsigned integer;                                        /* default system font size            */    /*<6>*/
        integer;                                                /* default application FOND ID        */    /*<6>*/
        unsigned integer;                                        /* default application font size    */    /*<6>*/
        integer;                                                /* default Help Mgr FOND ID            */    /*<6>*/
        unsigned integer;                                        /* default Help Mgr font size        */    /*<6>*/
        hex byte;                                                /* valid styles for script                /*<10>*/
        hex byte;                                                /* alias style for script            */    /*<10>*/
};
/*----------------------------itlc • International Configuration------------------------*/
type 'itlc' {
        unsigned integer;                                        /* system script code    */
        unsigned integer;                                        /* keyboard cache size    */
        byte            noFontForce, fontForce = 255;            /* font force flag        */
        byte            noIntlForce, intlForce = 255;            /* intl force flag        */
        byte            noOldKeyboard, oldKeyboard = 255;        /* old keyboard            */
        unsigned hex byte;                                        /* general flags - see
                                                                   smGenFlags info in
                                                                   ScriptEqu.a            */
        integer;                                                /* script icon offset    (not used in Sys 7 ) */
        byte            rightOffset, leftOffset = 255;            /* menu side for offset    (not used in Sys 7 ) */
        byte;                                                    /* icon data (rsvd)        (not used in Sys 7 ) */
        unsigned integer Region;                                /* pref. region code    */

        /* system flags */
        boolean            directionLeftRight, directionRightLeft;    /* to set TESysJust        */    /*<23>*/
        fill bit[15];                                            /* reserved                */    /*<23>*/

        /* for future expansion */
        hex string [32];                                        /* reserved                */    /*<23>*/
};
/*----------------------------itlk • Keyboard-dependent Remapping-----------------------*/
type 'itlk' {
        integer = $$CountOf(RemapItemArray);
        wide array RemapItemArray {
            integer;                                            /* keyboard type        */
            hex byte;                                            /* old modifier bits    */
            byte;                                                /* old key code            */
            hex byte;                                            /* modifier bits mask    */
            byte;                                                /* key code mask        */
            hex byte;                                            /* new modifier bits    */
            byte;                                                /* new key code            */
        };
};
/*----------------------------itlm • Multiscript mapping/sorting-----------------------*/
type 'itlm' {
        unsigned hex integer;                                    /* version number                    */
        unsigned hex integer;                                    /* format code                        */
        unsigned integer = 3;                                    /* number of offset/length pairs    */
        unsigned longint = scriptData >> 3;                        /* offset to scriptData table        */
        unsigned longint = (endScriptData - scriptData) >> 3;    /* length of scriptData table        */
        unsigned longint = langData >> 3;                        /* offset to langData table            */
        unsigned longint = (endLangData - langData) >> 3;        /* length of langData table            */
        unsigned longint = regionData >> 3;                        /* offset to regionData table        */
        unsigned longint = (endRegionData - regionData) >> 3;    /* length of regionData table        */

scriptData:
        integer Script;                                /* max script code for script->lang mapping        */
        integer Language;                            /* default lang code for scripts not in table    */
        integer = $$CountOf(scriptArray);            /* number of entries in table                    */
        array scriptArray {                            /* entries are ordered by script sort order        */
            integer Script;                            /* script code                                    */
            integer Language;                        /* default language code for script                */
        };
endScriptData:

langData:
        integer Language;                            /* max lang code for lang->script mapping        */
        integer Script;                                /* default script code for langs not in table    */
        integer = $$CountOf(langArray);                /* number of entries in table                    */
        array langArray {                            /* entries are ordered by lang sort order        */
            integer Language;                        /* language code                                */
            integer Script;                            /* code    of script to which this lang belongs    */
        };
endLangData:

regionData:
        integer Region;                                /* max region code for region->lang mapping        */
        integer Language;                            /* default lang code for regions not in table    */
        integer = $$CountOf(regionArray);            /* number of entries in table                    */
        array regionArray {                            /* entries are ordered by region sort order        */
            integer Region;                            /* region code                                    */
            integer Language;                        /* parent language code for region                */
        };
endRegionData:
};

/*----------------------------KCAP • Physical Layout of Keyboard------------------------*/
type 'KCAP' {
        rect;                                                    /* boundsRect            */
        rect;                                                    /* textRect                */
        integer = $$CountOf(MainArray);
        array MainArray {
            integer = $$CountOf(ShapeArray) - 1;
            wide array ShapeArray {
                point;                                            /* shapePoint            */
            };
            integer = $$CountOf(KeyArray) - 1;
            wide array KeyArray {
                byte;                                            /* mask                    */
                boolean                or, and;
                bitstring[7];                                    /* keyCode                */
                integer;                                        /* dv                    */
                integer;                                        /* dh                    */
            };
        };
};
/*----------------------------KCHR • ASCII Mapping (software)---------------------------*/
type 'KCHR' {
        integer;                                                /* Version                */
        wide array [$100] {                                        /* Indexes                */
            byte;
        };
        integer = $$CountOf(TableArray);
        array TableArray {
            wide array [$80] {                                    /* ASCII characters        */
                char;
            };
        };
        integer = $$CountOf(DeadArray);
        array DeadArray {
            byte;                                                /* Table number            */
            byte;                                                /* Virtual keycode        */
            integer = $$CountOf(CompletorArray);
            wide array CompletorArray {
                char;                                            /* Completor char        */
                char;                                            /* Substituting char    */
            };
            char;                                                /* No match char        */
            char;                                                /* 16-bits for the times
                                                                   when 8 isn't enough    */
        };
};
/*----------------------------KMAP • Keyboard Mapping (hardware)------------------------*/
type 'KMAP' {
        integer;                                                /* ID                    */
        integer;                                                /* Version                */
        wide array [$80] {                                        /* Raw to virtual        */
            byte;                                                /*  keycode map            */
        };
        integer = $$CountOf(ExceptionArray);
        wide array ExceptionArray {
            byte;                                                /* Raw keycode            */
            boolean            noXor, Xor;
            fill bit[3];
            bitstring[4];                                        /* ADB op                */
            pstring;
        };
};
/*----------------------------KSWP • Keyboard Swapping----------------------------------*/
type 'KSWP' {
        /* The expression below that calculates the number of elements in the
           array is complicated because of the way that $$ResourceSize works.
           $$ResourceSize returns the size of the resource.  When derez'ing a
           resource, the size of the resource is known from the start.  When
           rez'ing a resource, however, the size starts out at zero and is
           incremented each time a field is appended to the resource data.  In
           other words, while rez'ing, $$ResourceSize rarely returns the final
           size of the resource.  When rez'ing a KSWP, the array size expression
           is not evaluated until all of the array elements have been parsed.
           Since each array element is 4 bytes long (if you add up all the fields),
           the number of array elements is the size of the resource at that point
           divided by four.  Since the preprocessor value of "DeRez" is zero when
           Rez'ing, the expression is equivalent to $$ResourceSize / 4.  When
           derez'ing a KSWP, the value of $$ResourceSize is constant: always the
           total size of the resource, in bytes.  Since the resource contains 4
           bytes of fill at the end (which happens to be the size of an array
           element), we have to take that in consideration when calculating the
           size of the array.  Note that the preprocessor value of "DeRez" is one,
           when derez'ing.
        */
        wide array [$$ResourceSize / 4 - DeRez]{
            hex integer        Roman, Japanese, Chinese, Korean,    /* script code or verb    */
                            Arabic, Hebrew, Greek,
                            Rotate = -1, System = -2,
                            Alternate = -3, RotateKybd = -4,    /* <20> */
                            ToggleDirection = -9,
                            SetDirLeftRight = -15,
                            SetDirRightLeft = -16,
                            RomanIfOthers = -17;                /* <25> */
            unsigned byte;                                        /* virtual key code        */
            /* Modifiers */
            fill bit;                                            /* rControlOn,rControlOff*/
            fill bit;                                            /* rOptionOn,rOptionOff    */
            fill bit;                                            /* rShiftOn,rShiftOff    */
            boolean        controlOff, controlOn;
            boolean        optionOff, optionOn;
            fill bit;                                            /* capsLockOn,capsLockOff*/
            boolean        shiftOff, shiftOn;
            boolean        commandOff, commandOn;
        };
        fill long;
};
/*----------------------------mach • cdev filtering-------------------------------------*/
type 'mach' {
        unsigned hex integer;                                                /* Softmask    */
        unsigned hex integer;                                                /* Hardmask    */
};
/*----------------------------mcky • Mouse Tracking-------------------------------------*/
type 'mcky' {
        array [8] {
            unsigned byte;
        };
};
/*----------------------------mppc • MPP Configuration Resource-------------------------*/
type 'mppc' {
        unsigned hex longint;                                    /* Info passed to drvr    */
        byte;                                                    /* Override version #    */
        fill byte;                                                /* Reserved                */
};
/*----------------------------NFNT • Font Description-----------------------------------*/
type 'NFNT' as 'FONT';
/*----------------------------nrct • Rectangle List-------------------------------------*/
type 'nrct' {
        integer = $$CountOf(RectArray);                            /* Number of rectangles    */
        array RectArray {
            rect;
        };
};

/*----------------------------ROv# • ROM Resource Override------------------------------*/
type 'ROv#' {
        unsigned hex integer;                                    /* Version # of ROM        */
        integer = $$CountOf(typeList) - 1;                        /* Number of resources    */
        wide array typeList {
            literal longint;                                    /* Resource type        */
            integer;                                            /* Resource id            */
        };
};
/*----------------------------scrn • Screen Configuration-------------------------------*/
type 'scrn' {
        integer = $$CountOf(Device);                            /* Number of displays    */
        wide array Device {
            unsigned hex integer;                                /* sRsrc Type            */
            integer;                                            /* Slot number            */
            unsigned hex longint;                                /* dCtlDevBase            */
            integer;                                            /* sRsrcID for mode        */
            integer = $77FE;                                    /* Flag mask            */
            Boolean            inactive, active;                    /* Device active flag    */
            fill bit[3];                                         /* reserved             */
            Boolean            auxillaryScreen, mainScreen;        /* Main screen flag        */
            unsigned bitstring[10] = 0;                            /* reserved                */
            Boolean            monochrome, color;                    /* Device type            */
            integer;                                            /* Rsrc ID of 'clut'    */
            integer;                                            /* Rsrc ID of 'gama'    */
            Rect;                                                /* Device's global rect    */
            integer = $$CountOf(ControlCalls);                    /* # of control calls    */
            wide array ControlCalls {
                integer;                                        /* csCode for this call    */
                wstring;                                        /* param block data        */
                align word;

            };
        };
};
/*----------------------------snd  • Sound----------------------------------------------*/
type 'snd ' {
        switch {
            case FormatOne:
                key unsigned integer = $0001;
                unsigned integer = $$CountOf(Synthesizers);
                wide array Synthesizers {
                    /* Resource ID of synthesizer/modifer */
                    integer        squareWaveSynth        = $0001,
                                waveTableSynth        = $0003,
                                sampledSynth        = $0005;
                    longint;                                    /* init parameter        */
                };

            case FormatTwo:
                key unsigned integer = $0002;
                integer        free = 0, keepInMemory = 256+1;        /* Space for refe count    */
        };
        unsigned integer = $$CountOf(SoundCmnds);
        wide array SoundCmnds {
            boolean        noData, hasData;
            switch {
                case nullCmd:
                    key bitstring[15] = 0;
                    fill word;                                    /* Param 1 = nil        */
                    fill long;                                    /* Param 2 = nil        */
                case quietCmd:
                    key bitstring[15] = 3;
                    fill word;                                    /* Param 1 = nil        */
                    fill long;                                    /* Param 2 = nil        */
                case flushCmd:
                    key bitstring[15] = 4;
                    fill word;                                    /* Param 1 = nil        */
                    fill long;                                    /* Param 2 = nil        */
                case waitCmd:
                    key bitstring[15] = 10;
                    integer        oneSecond = 2000;                /* Duration                */
                    fill long;                                    /* Param 2 = nil        */
                case pauseCmd:
                    key bitstring[15] = 11;
                    fill word;                                    /* Param 1 = nil        */
                    fill long;                                    /* Param 2 = nil        */
                case resumeCmd:
                    key bitstring[15] = 12;
                    fill word;                                    /* Param 1 = nil        */
                    fill long;                                    /* Param 2 = nil        */
                case callBackCmd:
                    key bitstring[15] = 13;
                    integer;                                    /* User-defined            */
                    longint;                                    /* User-defined            */
                case syncCmd:
                    key bitstring[15] = 14;
                    integer;                                    /* Count                */
                    longint;                                    /* Identifier            */
                case emptyCmd:
                    key bitstring[15] = 15;
                    fill word;                                    /* Param 1 = nil        */
                    fill long;                                    /* Param 2 = nil        */
                case freqDurationCmd:
                    key bitstring[15] = 40;
                    integer        oneSecond = 2000;                /* Duration                */
                    longint;                                    /* frequency            */
                case restCmd:
                    key bitstring[15] = 41;
                    integer        oneSecond = 2000;                /* Duration                */
                    fill long;                                    /* Param 2 = nil        */
                case freqCmd:
                    key bitstring[15] = 42;
                    fill word;                                    /* Param 1 = nil        */
                    longint;                                    /* Frequency            */
                case ampCmd:
                    key bitstring[15] = 43;
                    integer;                                    /* Amplitude            */
                    fill long;                                    /* Param 2                */
                case timbreCmd:
                    key bitstring[15] = 44;
                    integer        sineWave, squareWave = 255;        /* Timbre                */
                    fill long;                                    /* Param 2                */
                case waveTableCmd:
                    key bitstring[15] = 60;
                    unsigned integer;                            /* Length                */
                    longint;                                    /* Pointer to table        */
                case phaseCmd:
                    key bitstring[15] = 61;
                    integer;                                    /* Shift                */
                    longint;                                    /* chanPtr                */
                case soundCmd:
                    key bitstring[15] = 80;
                    fill word;                                    /* Param 1 = nil        */
                    longint;                                    /* Pointer to sound        */
                case bufferCmd:
                    key bitstring[15] = 81;
                    fill word;                                    /* Param 1 = nil        */
                    longint;                                    /* Pointer to buffer    */
                case rateCmd:
                    key bitstring[15] = 82;
                    fill word;                                    /* Param 1 = nil        */
                    longint;                                    /* Rate                    */
            };
        };
        array DataTables {
    DataTable:
            fill long;                                            /* Pointer to data        */
    SampleCnt:
            unsigned longint;                                    /* # of sound samples    */
            unsigned hex longint
                    Rate22K = $56EE8BA3;                        /* Sampling rate        */
            unsigned longint;                                    /* Start of loop        */
            unsigned longint;                                    /* End of loop            */
            hex byte;                                            /* encode (header type)    */
            hex byte;                                            /* baseFrequency        */
            hex string [$$Long(SampleCnt[$$ArrayIndex(DataTables)])];
        };
};
/*----------------------------vers • Version--------------------------------------------*/
type 'vers' {
        hex byte;                                                /* Major revision in BCD*/
        hex byte;                                                /* Minor vevision in BCD*/
        hex byte    development = 0x20,                            /* Release stage        */
                    alpha = 0x40,
                    beta = 0x60,
                    final = 0x80, /* or */ release = 0x80;
        hex byte;                                                /* Non-final release #    */
        integer        Region;                                        /* Region code            */
        pstring;                                                /* Short version number    */
        pstring;                                                /* Long version number    */
};
/*--------------------------------------------------------------------------------------*/

/* FRSV and resf • reserved fonts */

    type 'FRSV' {
        integer = $$CountOf(ReservedFontArray);
        wide array ReservedFontArray {
            unsigned bitstring[9]    Chicago = 0, Geneva = 3, Monaco = 4;    // font family
            unsigned bitstring[7];                                            // font size
        };
    };

    type 'resf' {
        integer = $$CountOf(FamilyArray);
        array FamilyArray {
            pstring;
            align word;
            integer = $$CountOf(FontRecord);
            array FontRecord {
                integer;                        // point size
                integer plain;                    // style
            };
        };
    };

/* fld# • list of folder names for Folder Mgr */

    type 'fld#' {
        array {
            literal        longint;                // folder type
            integer        inSystemFolder = 0;        // version
            fill byte;                            // high byte of data length
            pstring;                            // folder name
            align word;
        };
    };

/* mitq • default queue sizes for MakeITable */

    type 'mitq' {                // default MakeITable queue sizes
        wide array [3] {
            unsigned longint;    // queue size for 3, 4, and 5 bit inverse tables
        };
    };

/* ppcc • PPC Browser Configuration Resource */

    type 'ppcc' {
        unsigned byte;    // NBP lookup interval
        unsigned byte;    // NBP lookup count
        integer;        // NBP maximum lives an entry has before deletion
        integer;        // NBP maximum number of entities
        integer;        // NBP idle time in ticks between lookups
        integer;        // PPC maximum number of ports
        integer;        // PPC idle time in ticks between list ports
    };

/*--------------------------------------------------------------------------------------*/

#endif __SYSTYPES_R__